#!/usr/bin/env node

const fs = require('fs');
const path = require('path');
const iconv = require('iconv-lite');

// 获取命令行参数
const args = process.argv.slice(2);

if (args.length === 0) {
  console.error('请提供要处理的.dat文件路径或目录路径');
  process.exit(1);
}

const inputPath = args[0];

// 检查路径是否存在
if (!fs.existsSync(inputPath)) {
  console.error(`路径不存在: ${inputPath}`);
  process.exit(1);
}

// 读取文件内容 (使用GBK编码)
function readDatFile(filePath) {
  const buffer = fs.readFileSync(filePath);
  return iconv.decode(buffer, 'gbk');
}

// 解析.dat文件内容并提取词汇关系
function extractWordRelations(content) {
  const wordRelations = {};
  
  // 通过*^分割条目
  const rawEntries = content.split('*^').filter(e => e.trim());
  
  for (const rawEntry of rawEntries) {
    try {
      // 查找^#的位置
      const splitIndex = rawEntry.indexOf('^#');
      if (splitIndex === -1) continue;
      
      const englishPart = rawEntry.substring(0, splitIndex);
      
      // 解析英文部分的单词关系
      const segments = englishPart.split(/\s*\^\s*/).filter(s => s.trim());
      
      for (const segment of segments) {
        if (segment.includes('$$$$')) {
          // 有注释的单词
          const parts = segment.split('$$$$');
          const wordPart = parts[0];
          
          if (wordPart.includes('$')) {
            const wordComponents = wordPart.split('$');
            const word = wordComponents[0];  // 实际使用的词
            const baseForm = wordComponents[1];  // 词根/原型
            
            if (word.trim() && baseForm.trim() && word.trim().toLowerCase() !== baseForm.trim().toLowerCase()) {
              // 只有当词形和原型不同时才存储，并且转为小写
              wordRelations[word.trim().toLowerCase()] = baseForm.trim().toLowerCase();
            }
          }
        }
      }
    } catch (error) {
      console.error('解析条目时出错:', error);
      continue;
    }
  }
  
  return wordRelations;
}

// 处理单个文件
function processFile(datFilePath) {
  try {
    console.log(`处理文件: ${datFilePath}`);
    
    // 读取.dat文件
    const content = readDatFile(datFilePath);
    
    // 提取词汇关系
    const wordRelations = extractWordRelations(content);
    
    // 保存到resources/dic目录
    saveWordRelations(wordRelations);
    
    console.log(`共处理了 ${Object.keys(wordRelations).length} 个词形变化关系`);
  } catch (error) {
    console.error(`处理文件 ${datFilePath} 时出错:`, error);
  }
}

// 保存词汇关系到resources/dic目录
function saveWordRelations(wordRelations) {
  const dicBasePath = path.join(__dirname, '..', 'resources', 'dic');
  
  for (const [word, baseForm] of Object.entries(wordRelations)) {
    // 获取首字母
    const firstLetter = word.charAt(0).toLowerCase();
    
    // 确保首字母是英文字母
    if (!/[a-z]/.test(firstLetter)) {
      continue;
    }
    
    // 构建目标目录路径
    const targetDir = path.join(dicBasePath, firstLetter);
    
    // 确保目录存在
    if (!fs.existsSync(targetDir)) {
      fs.mkdirSync(targetDir, { recursive: true });
    }
    
    // 构建文件名（键值对格式）
    const fileName = `${word}-${baseForm}`;
    const filePath = path.join(targetDir, fileName);
    
    // 如果文件不存在，则创建空文件
    if (!fs.existsSync(filePath)) {
      fs.writeFileSync(filePath, '');
      console.log(`已创建文件: ${filePath}`);
    }
  }
}

// 处理目录
function processDirectory(dirPath) {
  const files = fs.readdirSync(dirPath);
  
  for (const file of files) {
    if (path.extname(file) === '.dat') {
      const fullPath = path.join(dirPath, file);
      processFile(fullPath);
    }
  }
}

// 主处理逻辑
if (fs.statSync(inputPath).isDirectory()) {
  processDirectory(inputPath);
} else {
  processFile(inputPath);
}